NAZWA¶

perldata - typy danych Perla

OPIS¶

Nazwy zmiennych

Perl posiada trzy typy struktur danych: skalary, tablice skalarów oraz asocjacyjne tablice skalarów, zwane też "haszami" ("hashes"). Zwykłe tablice indeksowane są liczbami, począwszy od 0 (indeksy ujemne są liczone od końca tablicy). Tablice asocjacyjne indeksowane są łańcuchami.

Wartości są zwykle przypisane do nazwy (lub nazwanego odwołania). Pierwszy znak nazwy mówi o tym, do jakiego rodzaju struktury danych się ona odnosi. Reszta nazwy określa konkretną wartość, do której odnosi się nazwa. Najczęściej składa się ona z pojedynczego identyfikatora, to znaczy, łańcucha rozpoczynającego się literą lub znakiem podkreślenia i zawierającego litery, podkreślenia i cyfry. W niektórych przypadkach może być ciągiem identyfikatorów, rozdzielonych przez :: (lub przez ', ale nie jest to polecane). Wszystkie oprócz ostatniego interpretowane są jako nazwy pakietów, wskazując przestrzenie nazw, w których będzie wyszukiwany ostatni identyfikator (szczegóły znajdziesz w sekcji Packages podręcznika perlmod(1)). Możliwe jest zastąpienie prostego identyfikatora wyrażeniem, które w czasie wykonania tworzy odwołanie do wartości; jest to opisane szczegółowo poniżej oraz na stronie perlref(1) podręcznika.

Istnieją również zmienne specjalne, których nazwy nie przestrzegają powyższych reguł, po to by nie kolidowały przypadkowo z którąś z twych zwykłych zmiennych. Łańcuchy, które pasują do objętych nawiasami okrągłymi części wyrażenia regularnego zachowywane są pod nazwami zawierającymi tylko cyfry po znaku $ (patrz strony perlop(1) i perlre(1) dokumentacji). Dodatkowo, kilka zmiennych specjalnych, umożliwiających dostęp do wewnętrznych rozwiązań Perla, posiada nazwy zawierające znaki przestankowe (zobacz strony perlvar(1) dokumentacji).

Wartości skalarne zawsze noszą nazwy rozpoczynające się znakiem '$', nawet, gdy odnoszą się do skalara będącego częścią tablicy. Działa to podobnie jak angielski przedimek "the". A zatem mamy:

    $dni             # zwykła wartość skalarna "dni"
    $dni[28]         # 29-ty element tablicy
    $dni{'luty'}     # wartość dla klucza 'luty' z hasza %dni
    $#dni            # ostatni indeks tablicy @dni

    @dni             # ($dni[0], $dni[1],... $dni[n])
    @dni[3,4,5]      # to samo, co @dni[3..5]
    @dni{'a','c'}    # to samo, co ($dni{'a'},$dni{'c'})

    %dni             # (klucz1, wartość1, klucz2, wartość2 ...)

Każdy typ zmiennych ma swoją własną przestrzeń nazw. Możesz, bez obawy o konflikt, używać tej samej nazwy dla zmiennej skalarnej, tablicy czy tablicy asocjacyjnej (lub uchwytu pliku, nazwy procedury czy etykiety). Oznacza to, że $foo i @foo są dwoma różnymi zmiennymi. Znaczy to też, że $foo[1] jest częścią tablicy @foo, nie zaś częścią skalara $foo. Może się to wydawać trochę dziwne, ale tak ma być, gdyż to jest dziwne.

Ponieważ odniesienia do zmiennych i tablic zawsze rozpoczynają się od nie są naprawdę zarezerwowane w odniesieniu do nazw zmiennych. (Jednak SĄ one zarezerwowane w odniesieniu do etykiet i uchwytów plików, które nie posiadają specjalnego początkowego znaku. Nie możesz, na przykład, użyć uchwytu pliku o nazwie "log". Wskazówka: możesz napisać open(LOG,'logfile') zamiast open(log,'logfile'). Użycie nazw uchwytów plików złożonych z dużych liter poprawia również czytelność i chroni przed konfliktami z przyszłymi słowami zastrzeżonymi. Wielkość liter JEST znacząca--"FOO", "Foo" oraz "foo" są zupełnie innymi nazwami. Nazwy rozpoczynające się literą lub znakiem podkreślenia mogą zawierać również cyfry i podkreślenia.

Możliwe jest zastąpienie takiej alfanumerycznej nazwy wyrażeniem, które zwraca odwołanie do obiektu danego typu. Opis tego znajdziesz na stronie perlref(1) podręcznika.

Nazwy rozpoczynające się cyfrą mogą zawierać tylko cyfry. Nazwy, które nie zaczynają się od litery, podkreślenia ani cyfry ograniczone są do pojedynczego znaku, np. $% czy $$. (Większość z tych jednoznakowych nazw ma predefiniowane znaczenie dla Perla. Na przykład, $$ jest identyfikatorem bieżącego procesu.)

Kontekst

Interpretacja operacji i wartości w Perlu zależy czasami od wymagań kontekstu, w jakim użyta jest operacja czy wartość. Istnieją dwa główne konteksty: skalarny i listowy. Niektóre z operacji zwracają wartości listowe w kontekście oczekującym listy, zaś wartości skalarne w przeciwnym przypadku. (Jeśli tak jest dla danej operacji, to zostanie to wspomniane w jej opisie.) Innymi słowy, Perl przeciąża pewne operacje w oparciu o to, czy spodziewana jest pojedyncza wartość czy mnoga. (W podobny sposób funkcjonują w języku angielskim niektóre słowa, jak "fish" czy "sheep".)

Na zasadzie wzajemności, operacja dostarcza albo kontekstu skalarnego albo listowego każdemu ze swych argumentów. Na przykład, jeśli napiszesz

    int( <STDIN> )

    sort( <STDIN> )

Przypisanie jest trochę specyficzne, w tym, iż posługuje się swym lewym argumentem do ustalenia kontekstu dla prawego argumentu. Przypisanie do skalara oblicza prawą stronę w kontekście skalarnym, podczas gdy przypisanie do tablicy lub wycinka tablicy rozwija prawą stronę w kontekście listowym. Przypisanie do listy również oblicza prawą stronę w kontekście listowym.

Procedury definiowane przez użytkownika mogą sprawdzać, czy są wywołane w kontekście skalarnym czy listowym, ale większość z nich nie dba o to, gdyż skalary są automatycznie interpolowane w listy. Zobacz opis funkcji wantarray na stronie perlfunc(1).

Wartości skalarne

Wszystkie dane w Perlu są skalarami lub tablicami skalarów albo haszami skalarów. Zmienne skalarne mogą zawierać różne rodzaje pojedynczych danych, jak liczby, łańcuchy znakowe czy odwołania. Ogólnie, konwersja z jednej postaci na drugą jest transparentna. (Skalar nie może zawierać wielu wartości, ale może zawierać odwołanie do tablicy czy hasza zawierających wiele wartości.) Z powodu automatycznej konwersji skalarów, operatory i funkcje zwracające skalary nie muszą dbać o to (i faktycznie nie dbają), czy kontekst oczekuje łańcucha czy też liczby.

Skalary nie są koniecznie tą czy inną rzeczą. Nie ma możliwości zadeklarowania zmiennej skalarnej o typie "string", "number", typu "filehandle", czy jakiegoś innego. Perl jest językiem kontekstowo polimorficznym, w którym skalary mogą być łańcuchami, liczbami czy odwołaniami (co obejmuje obiekty). Łańcuchy i liczby uważane są za mniejwięcej to samo w niemal każdym zastosowaniu. Odwołania są jednak nierzutowalnymi wskaźnikami o ściśle określonym typie, z wbudowanym licznikiem odwołań i wywołaniami destruktora.

Wartość skalarna interpretowana jest jako prawda, TRUE, w sensie logiki boolowskiej, jeśli nie jest łańcuchem pustym ani liczbą zero (lub jej łańcuchowym równoważnikiem, "0"). Kontekst boolowski (logiczny) jest po prostu specyficznym rodzajem kontekstu skalarnego.

Faktycznie istnieją dwie odmiany skalarów pustych: zdefiniowane i niezdefiniowane. Niezdefiniowane skalary puste zwracane są gdy brak jest rzeczywistej wartości czegoś, jak w przypadku wystąpienia błędu lub na końcu pliku, albo gdy odwołujesz się do niezdefiniowanej zmiennej czy elementu tablicy. Niezdefiniowany pusty skalar może stać się zdefiniowany po tym, jak po raz pierwszy użyjesz go tak, jakby był zdefiniowany. Ale przed tym możesz posłużyć się operatorem defined(), by stwierdzić, czy wartość jest zdefiniowana czy też nie.

By stwierdzić, czy dany łańcuch jest poprawną liczbą niezerową wystarczy zwykle porównać go zarówno z numerycznym 0 jak i leksykalnym "0" (choć spowoduje to ostrzeżenia opcji -w). Sposób ten wynika stąd, że łańcuchy nie będące liczbami uważane są za 0, tak jak w awk:

    if ($str == 0 && $str ne "0")  {
        warn "To nie wygląda na liczbę";
    }

    warn "has nondigits"        if     /\D/;
    warn "not a natural number" unless /^\d+$/;              # odrzuca -3
    warn "not an integer"       unless /^-?\d+$/;            # odrzuca +3
    warn "not an integer"       unless /^[+-]?\d+$/;
    warn "not a decimal number" unless /^-?\d+\.?\d*$/;    # odrzuca .2
    warn "not a decimal number" unless /^-?(?:\d+(?:\.\d*)?⎪\.\d+)$/;
    warn "not a C float"
        unless /^([+-]?)(?=\d⎪\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/;

    @cokolwiek = ();
    $#cokolwiek = -1;

    scalar(@cokolwiek) == $#cokolwiek - $[ + 1;

    scalar(@cokolwiek) == $#cokolwiek + 1;

    $liczba_elementow = scalar(@cokolwiek);

Możesz wstępnie przydzielić miejsce na hasz przy pomocy przypisania do funkcji keys(). Zaokrągli to zaalokowane jednostki komórek do najbliższej potęgi dwójki.

    keys(%users) = 1000;                # zaalokuj 1024 buckets

Konstruktory wartości skalarnych

Literały numeryczne podawane są w zwyczajowych formatach zmiennoprzecinkowych lub całkowitych:

    12345
    12345.67
    .23E-10
    0xffff           # hex
    0377             # ósemkowa
    4_294_967_296    # podkreślenie dla lepszej czytelności

Zapisy ósemkowe czy szesnastkowe w literałach łańcuchowych (np. '0xffff') nie są automatycznie zamieniane na ich całkowitą reprezentację. Konwersje te wykonują funkcje hex() i oct(). Więcej szczegółów znajdziesz w opisach tych funkcji w podręczniku perlfunc(1).

Możesz też umieszczać znaki nowej linii bezpośrednio w łańcuchach, tj., mogą one kończyć się w innym wierszu niż się rozpoczęły. Jest to przyjemne, ale jeżeli zapomnisz zamykającego cudzysłowu, to błąd nie będzie zgłaszany dopóty, dopóki Perl nie znajdzie innego wiersza, zawierającego znak cudzysłowu, który może znajdować się o wiele dalej w skrypcie. Zastępowanie zmiennych w łańcuchach ograniczone jest do zmiennych skalarnych, tablic oraz wycinków tablic. (Inaczej mówiąc, nazw rozpoczynających się od $ lub @, po których może opcjonalnie wystąpić, ujęte w nawiasy kwadratowe, wyrażenie traktowane jako indeks elementu tablicy.) Poniższy fragment kodu drukuje "Cena wynosi $100."

    $cena = '$100';    # nie interpretowane
    print "Cena wynosi $cena.\n";     # interpretowane

    $dni{'luty'}

    $dni{luty}

Zauważ, że łańcuch w pojedynczych cudzysłowach musi być oddzielony od poprzedzającego go słowa odstępem, gdyż pojedynczy cudzysłów jest poprawnym (choć nie zalecanym) znakiem w nazwie zmiennej (zobacz Packages w podręczniku perlmod(1)).

Trzema specjalnymi literałami są __FILE__, __LINE__ oraz __PACKAGE__, które reprezentują nazwę bieżącego pliku, numer wiersza oraz nazwę pakietu w danym punkcie twego programu. Mogą być używane wyłącznie jako odrębne tokeny. Nie będą one interpolowane wewnątrz łańcuchów. Jeżeli nie ma bieżącego pakietu (z powodu pustej dyrektywy package;), to __PACKAGE__ jest wartością niezdefiniowaną.

Tokenami __END__ i __DATA__ można posługiwać się do wskazania logicznego końca skryptu przed faktycznym końcem pliku. Dowolny następujący po nich tekst jest ignorowany, ale może być odczytany przy pomocy uchwytu DATA. Wykorzystaj main::DATA dla użytego tokenu __END__, lub też NAZWAPAKIETU::DATA (gdzie NAZWAPAKIETU jest bieżącym pakietem) dla __DATA__. Dwa znaki sterujące: ^D i ^Z są synonimami dla __END__ (lub __DATA__ w module). Szerszy opis __DATA__ i przykład użycia znajdziesz w podręczniku SelfLoader. Zauważ, że nie można czytać z uchwytu pliku DATA w bloku BEGIN. Blok ten jest wykonywany natychmiast po napotkaniu (w czasie kompilacji). W tym momencie nie został jeszcze znaleziony odpowiedni token __DATA__ (lub __END__).

Słowo nie posiadające żadnej innej interpretacji w gramatyce Perla będzie traktowane tak, jakby znajdowało się w cudzysłowie. Są one znane pod nazwą "gołych słów" ("barewords"). Tak samo, jak w przypadku etykiet i uchwytów plików, gołe słowa składające się wyłącznie z małych liter narażają na konlikt z przyszłymi słowami zastrzeżonymi. Jeżeli użyjesz przełącznika -w, to Perl będzie ostrzegał o wystąpieniu takich słów. Niektórzy chcieliby całkowicie wyjąć spod prawa gołe słowa. Jeśli napiszesz

    use strict 'subs';

Zmienne tablicowe w łańcuchach objętych cudzysłowami interpolowane są przez złączenie wszystkich elementów tablicy. Elementy są wówczas rozdzielone ogranicznikiem podanym w zmiennej $" ($LIST_SEPARATOR w module English), domyślnie spacją. Poniższe fragmenty są równoważne:

    $temp = join($",@ARGV);
    system "echo $temp";

    system "echo @ARGV";

Wierszowa forma cytowania oparta jest na składni "dokumentów-tutaj" używanej ("here-doc") w powłokach. Po sekwencji << podajesz napis ograniczający cytowany materiał, a wszystkie wiersze poniżej bieżącego aż do napisu kończącego są wartością elementu. Napisem kończącym może być identyfikator (słowo) albo jakiś cytowany tekst. Jeżeli jest to tekst cytowany, to rodzaj zastosowanych znaków cytowania określa traktowanie tekstu, tak jak przy zwykłym cytowaniu. Niecytowany identyfikator działa tak, jakby był w podwójnym cudzysłowie. Pomiędzy << a identyfikatorem nie może wystąpić spacja. (Jeżeli wstawisz spację, to będzie ona traktowany jak pusty identyfikator, co jest poprawne i dopasowuje pierwszy pusty wiersz.) Napis kończący musi pojawić się w wierszu kończącym samotnie (niecytowany i bez otaczających białych znaków).

        print <<EOF;
    Cena wynosi $cena.
    EOF

        print <<"EOF";  # to samo, co powyżej
    Cena wynosi $cena.
    EOF

        print <<`EOC`;  # wykonaj polecenia
    echo hi there
    echo lo there
    EOC

        print <<"foo", <<"bar"; # możesz składować, jeden za drugim
    I said foo.
    foo
    I said bar.
    bar

        myfunc(<<"TO", 23, <<'TAMTO');
    Masz tu linijkę
    czy dwie.
    TO
    a tu jeszcze jedną.
    TAMTO

        print <<ABC
    179231
    ABC
        + 20;

Konstruktory wartości listowych

Wartości listowe oznaczane są przez oddzielenie pojedynczych wartości przecinkami (i otoczenie listy nawiasami jeśli wymaga tego kolejność):

    (LIST)

    @foo = ('cc', '-E', $bar);

    $foo = ('cc', '-E', $bar);

    @foo = ('cc', '-E', $bar);
    $foo = @foo;                # $foo dostaje 3

    @foo = (
        1,
        2,
        3,
    );

    (@foo,@bar,&SomeSub,%glarch)

Lista pusta reprezentowana jest przez (). Jej interpolowanie w liście nie daje żadnego efektu. Zatem ((),(),()) jest równoważne (). Podobnie, interpolowanie tablicy bez elementów jest tym samym, co nie interpolowanie w tym miejscu żadnej tablicy.

Wartość listowa może być też indeksowana tak, jak zwykła tablica. Musisz tylko umieścić listę w nawiasach, by uniknąć niejasności. Na przykład:

    # Stat zwraca wartość listową
    $time = (stat($file))[8];

    # TUTAJ BŁĄD SKŁADNI
    $time = stat($file)[8];  # Oj, zapomniałem nawiasów

    # znajdź cyfrę szesnastkową
    $hexdigit = ('a','b','c','d','e','f')[$digit-10];

    # "reverse comma operator"
    return (pop(@foo),pop(@foo))[0];

    ($dev, $ino, undef, undef, $uid, $gid) = stat($file);

    ($a, $b, $c) = (1, 2, 3);

    ($map{'czerwony'}, $map{'niebieski'}, $map{'zielony'}) 
                                              = (0x00f, 0x0f0, 0xf00);

    $x = (($foo,$bar) = (3,2,1));  # ustaw $x na 3, nie 2
    $x = (($foo,$bar) = f()); # ustaw $x na ilość zwróconych przez f()

Ostatni element może być tablicą lub haszem:

    ($a, $b, @rest) = split;
    my($a, $b, %rest) = @_;

Literał hasza (tablicy asocjacyjnej) zawiera pary wartości, które będą interpretowane jako klucz i wartość:

    # takie samo przypisanie jak powyżej
    %map = ('czerwony',0x00f,'niebieski',0x0f0,'zielony',0xf00);

Często bardziej czytelne jest użycie pomiędzy parami klucz/wartość operatora =>. Operator ten jest po prostu bardziej wyróżniającym się wzrokowo synonimem przecinka. Ponadto powoduje, że jego lewostronny operand jest interpretowany jako łańcuch, jeśli jest on gołym słowem, które mogłoby być poprawnym identyfikatorem. Uprzyjemnia to inicjowanie haszy:

    %map = (
                 czerwony  => 0x00f,
                 niebieski => 0x0f0,
                 zielony   => 0xf00,
   );

    $rec = {
                witch => 'Mable the Merciless',
                cat   => 'Fluffy the Ferocious',
                date  => '10/31/1776',
    };

   $field = $query->radio_group(
               name      => 'group_name',
               values    => ['eenie','meenie','minie'],
               default   => 'meenie',
               linebreak => 'true',
               labels    => \%labels
   );

Typeglob i uchwyty plików

Perl posługuje się wewnętrznym typem zwanym typeglob. Przechowuje w nim wszystkie zapisy tablicy symboli. Przedrostkiem typu typeglob jest *, gdyż reprezentuje on wszystkie typy. Był on zalecanym sposobem przekazywania tablic i tablic asocjacyjnych przez odwołanie do funkcji, ale obecnie istnieją prawdziwe odwołania, więc jest to rzadko potrzebne.

Podstawowym zastosowaniem typeglob we współczesnym Perlu jest tworzenie synonimów tablicy symboli. To przypisanie:

    *cos = *inne;

    local *Tutaj::niebieski = \$Tam::zielony;

Innym zastosowaniem typeglob jest przesyłanie uchwytów plików do funkcji lub tworzenie nowych uchwytów. Jeżeli potrzebujesz posłużyć się typeglob, by zachować uchwyt pliku, zrób to tak:

    $fh = *STDOUT;

    $fh = \*STDOUT;

Typeglob są również sposobem na tworzenie lokalnych uchwytów plików przy użyciu operatora local(). Istnieją wówczas aż do wyjścia z ich bloku, ale mogą być przesłane powtórnie. Na przykład:

    sub newopen {
        my $path = shift;
        local *FH;  # nie my!
        open   (FH, $path)          or  return undef;
        return *FH;
    }
    $fh = newopen('/etc/passwd');

Inną metodą tworzenia anonimowych uchwytów plików jest wykorzystanie modułu IO::Handle. Zaletą tych modułów jest nieukrywanie różnych typów tej samej nazwy podczas local(). Na końcu opisu open() w podręczniku perlfunc(1) zamieszczono odpowiedni przykład.

Dalsze rozważania na temat typeglob i składni *foo{THING} znajdziesz w podręcznikach perlref(1) i perlsub(1), a także w sekcji Symbol Tables podręcznika perlmod(1).